// ============================================================================
// c12_float_formatting - 浮点数格式化：输出控制与舍入
// 
// 本程序全面演示Rust中浮点数的各种格式化方法，包括精度控制、
// 科学计数法、舍入策略、对齐方式以及在实际应用中的格式化技巧。
//
// 主要学习内容：
// 1. Display和Debug格式化的区别
// 2. 精度控制和小数点位数设置
// 3. 科学计数法和工程记数法
// 4. 不同的舍入策略
// 5. 填充、对齐和符号控制
// 6. 特殊值（NaN、无穷大）的格式化
// 7. 货币、百分比等实际应用格式
// 8. 自定义格式化实现
// ============================================================================

use std::fmt;

fn main() {
    println!("=== c12_float_formatting: 浮点数格式化详解 ===\n");
    
    // 1. 基础格式化方法
    demonstrate_basic_formatting();
    
    // 2. 精度控制
    demonstrate_precision_control();
    
    // 3. 科学计数法格式化
    demonstrate_scientific_notation();
    
    // 4. 填充和对齐
    demonstrate_padding_alignment();
    
    // 5. 符号控制
    demonstrate_sign_control();
    
    // 6. 舍入行为详解
    demonstrate_rounding_behavior();
    
    // 7. 特殊值格式化
    demonstrate_special_values_formatting();
    
    // 8. 数字分组和千位分隔符
    demonstrate_number_grouping();
    
    // 9. 货币和百分比格式化
    demonstrate_currency_percentage();
    
    // 10. 自定义格式化实现
    demonstrate_custom_formatting();
    
    println!("\n=== 格式化演示完成 ===");
}

/// 1. 基础格式化方法演示
/// 展示Display、Debug等基本格式化特性
fn demonstrate_basic_formatting() {
    println!("1. 基础格式化方法");
    println!("   探索Display、Debug等基本格式化方式\n");
    
    let numbers = [
        123.456789,
        -987.654321,
        0.000123456,
        123456789.0,
        42.0,
    ];
    
    println!("1.1 Display格式化 ({{}}): 用户友好的显示格式");
    for &num in &numbers {
        println!("  {} -> 显示为: {}", num, num);
    }
    
    println!("\n1.2 Debug格式化 ({{:?}}): 开发调试用的详细格式");
    for &num in &numbers {
        println!("  {:?} -> 调试显示: {:?}", num, num);
    }
    
    println!("\n1.3 Lower Exp格式化 ({{:e}}): 小写科学计数法");
    for &num in &numbers {
        println!("  {} -> 科学计数法: {:e}", num, num);
    }
    
    println!("\n1.4 Upper Exp格式化 ({{:E}}): 大写科学计数法");
    for &num in &numbers {
        println!("  {} -> 大写科学计数法: {:E}", num, num);
    }
    
    // 特殊说明：Display vs Debug的差异
    println!("\n💡 Display vs Debug的重要差异:");
    println!("   - Display ({{}}): 面向最终用户，追求可读性");
    println!("   - Debug ({{:?}}): 面向开发者，显示更多技术细节");
    println!("   - 对于浮点数，两者通常显示相同，但在某些情况下可能不同");
    
    println!("\n{}\n", "=".repeat(60));
}

/// 2. 精度控制演示
/// 详细展示小数点位数控制的各种方法
fn demonstrate_precision_control() {
    println!("2. 精度控制");
    println!("   掌握小数点位数的精确控制方法\n");
    
    let test_values = [
        std::f64::consts::PI,           // π ≈ 3.141592653589793
        std::f64::consts::E,            // e ≈ 2.718281828459045
        1.0 / 3.0,                      // 1/3 ≈ 0.333333333...
        123.456789012345,               // 较长的小数
        0.000000123456789,              // 很小的数
        999999.999999,                  // 接近整数的大数
    ];
    
    println!("2.1 固定精度格式化 - 控制小数点后位数");
    let precisions = [0, 1, 2, 3, 4, 6, 10];
    
    for &value in &test_values {
        println!("\n  原始值: {}", value);
        for &p in &precisions {
            println!("    精度{:2}: {:.precision$}", p, value, precision = p);
        }
    }
    
    println!("\n2.2 动态精度控制 - 运行时决定精度");
    let value = std::f64::consts::PI;
    for precision in 0..=8 {
        println!("  π 保留{}位小数: {:.precision$}", 
                precision, value, precision = precision);
    }
    
    println!("\n2.3 最小宽度与精度结合");
    let value = 42.123456789;
    println!("  基本格式:           '{}'", value);
    println!("  宽度15:             '{:15}'", value);
    println!("  宽度15精度3:        '{:15.3}'", value);
    println!("  宽度15精度3右对齐:  '{:>15.3}'", value);
    println!("  宽度15精度3左对齐:  '{:<15.3}'", value);
    println!("  宽度15精度3居中:    '{:^15.3}'", value);
    
    println!("\n2.4 精度对不同数值范围的影响");
    let ranges = [
        (0.000001, "微小数值"),
        (0.1, "小数"),
        (1.0, "个位数"),
        (100.0, "百位数"),
        (10000.0, "万位数"),
        (1000000.0, "百万位数"),
    ];
    
    for (base, desc) in ranges {
        let value = base * std::f64::consts::PI;
        println!("  {}: {:.6} (6位精度)", desc, value);
        println!("    -> 科学计数法: {:e}", value);
    }
    
    println!("\n💡 精度控制要点:");
    println!("   - 精度指定的是小数点后的位数");
    println!("   - 超出精度的部分会被舍入（默认四舍五入）");
    println!("   - 精度为0时显示为整数形式");
    println!("   - 科学计数法的精度控制有效数字的总数");
    
    println!("\n{}\n", "=".repeat(60));
}

/// 3. 科学计数法格式化演示
/// 详细展示科学计数法在不同场景下的应用
fn demonstrate_scientific_notation() {
    println!("3. 科学计数法格式化");
    println!("   掌握科学计数法的各种表示方法\n");
    
    let scientific_values = [
        6.02214076e23,    // 阿伏伽德罗常数
        1.602176634e-19,  // 基本电荷
        6.67430e-11,      // 万有引力常数
        299792458.0,      // 光速（m/s）
        9.10938356e-31,   // 电子质量
        1.38064852e-23,   // 玻尔兹曼常数
        0.000000001,      // 纳米级别
        1234567890000.0,  // 万亿级别
    ];
    
    println!("3.1 小写科学计数法 ({{:e}})");
    for &value in &scientific_values {
        println!("  {:25} -> {:e}", value, value);
    }
    
    println!("\n3.2 大写科学计数法 ({{:E}})");
    for &value in &scientific_values {
        println!("  {:25} -> {:E}", value, value);
    }
    
    println!("\n3.3 科学计数法精度控制");
    let value = std::f64::consts::PI * 1e6;  // π × 10⁶
    for precision in 0..=8 {
        println!("  {}位有效数字: {:.*e}", precision + 1, precision, value);
    }
    
    println!("\n3.4 科学计数法与常规格式的对比");
    let comparison_values = [
        0.000000123,
        0.000123,
        0.123,
        123.0,
        123000.0,
        123000000.0,
        123000000000.0,
    ];
    
    println!("  {:>15} | {:>15} | {:>15}", "原始值", "常规格式", "科学计数法");
    println!("  {:-<15}-+-{:-<15}-+-{:-<15}", "", "", "");
    for &value in &comparison_values {
        println!("  {:>15} | {:>15} | {:>15e}", value, value, value);
    }
    
    println!("\n3.5 工程记数法模拟 (指数为3的倍数)");
    // Rust标准库没有直接的工程记数法，但我们可以手动实现
    for &value in &scientific_values {
        let eng_notation = format_engineering_notation(value, 3);
        println!("  {:15e} -> {}", value, eng_notation);
    }
    
    println!("\n3.6 科学计数法的对齐和填充");
    let align_values = [1.23e-4, 5.67e8, -9.87e-12, 4.56e15];
    println!("  左对齐15位:   右对齐15位:   居中15位:     零填充15位:");
    for &value in &align_values {
        println!("  {:<15e}   {:>15e}   {:^15e}   {:015e}", value, value, value, value);
    }
    
    println!("\n💡 科学计数法使用建议:");
    println!("   - 非常大或非常小的数值使用科学计数法更清晰");
    println!("   - 精度控制影响的是有效数字总数，不是小数点后位数");
    println!("   - 'e'用于小写输出，'E'用于大写输出");
    println!("   - 工程记数法适用于工程计算（指数为3的倍数）");
    
    println!("\n{}\n", "=".repeat(60));
}

/// 4. 填充和对齐演示
/// 展示各种对齐方式和填充字符的使用
fn demonstrate_padding_alignment() {
    println!("4. 填充和对齐");
    println!("   掌握数字的对齐、填充和格式控制\n");
    
    let align_values = [
        42.0,
        -123.456,
        1.23e-4,
        9876.54321,
        0.0001,
        std::f64::INFINITY,
        -std::f64::INFINITY,
    ];
    
    println!("4.1 基本对齐方式（宽度15）");
    println!("  {:>15} | {:<15} | {:>15} | {:^15}", "原值", "左对齐", "右对齐", "居中对齐");
    println!("  {:-<15}-+-{:-<15}-+-{:-<15}-+-{:-<15}", "", "", "", "");
    
    for &value in &align_values {
        println!("  {:>15} | {:<15} | {:>15} | {:^15}", value, value, value, value);
    }
    
    println!("\n4.2 零填充 - 数字前补零");
    println!("  零填充在数值显示中特别有用，如文件编号、时间等");
    for &value in &align_values {
        println!("  {:>15} -> 零填充: {:015}", value, value);
    }
    
    println!("\n4.3 自定义填充字符");
    let custom_values = [42.5, -17.25, 100.0];
    println!("  使用不同字符进行填充:");
    for &value in &custom_values {
        println!("  原值: {:>8}", value);
        println!("    '*' 填充: {:*>12}", value);
        println!("    '#' 填充: {:#>12}", value);
        println!("    '.' 填充: {:.<12}", value);
        println!("    '=' 填充: {:=^12}", value);  // 居中填充
    }
    
    println!("\n4.4 精度与对齐结合");
    let value = std::f64::consts::PI;
    println!("  π的不同格式化组合:");
    println!("  基础:           '{}'", value);
    println!("  2位精度:        '{:.2}'", value);
    println!("  宽度12,2位精度: '{:12.2}'", value);
    println!("  左对齐:         '{:<12.2}'", value);
    println!("  右对齐:         '{:>12.2}'", value);
    println!("  居中对齐:       '{:^12.2}'", value);
    println!("  零填充:         '{:012.2}'", value);
    
    println!("\n4.5 表格式对齐演示");
    let table_data = [
        ("苹果", 1.23, 45.0),
        ("香蕉", 234.567, 1200.0),
        ("橙子", 56.78, 89.12),
        ("葡萄", 9.0, 567.89),
    ];
    
    println!("  商品价格表（右对齐数字）:");
    println!("  {:<8} | {:>10} | {:>10}", "商品", "单价", "总价");
    println!("  {:-<8}-+-{:->10}-+-{:->10}", "", "", "");
    for (item, price, total) in table_data {
        println!("  {:<8} | {:>10.2} | {:>10.2}", item, price, total);
    }
    
    println!("\n4.6 负数的对齐处理");
    let positive_negative = [42.5, -42.5, 123.456, -123.456];
    println!("  负数符号的对齐影响:");
    for &value in &positive_negative {
        println!("  {:>10} | {:>10.2} | {:010.2}", value, value, value);
        //           基础右对齐  精度右对齐  零填充
    }
    
    println!("\n💡 对齐和填充要点:");
    println!("   - 左对齐 '<'：内容靠左，右侧填充");
    println!("   - 右对齐 '>'：内容靠右，左侧填充（数字默认）");
    println!("   - 居中 '^'：内容居中，两侧填充");
    println!("   - 零填充 '0'：数字前补零，符号后补零");
    println!("   - 自定义填充字符必须是单个ASCII字符");
    
    println!("\n{}\n", "=".repeat(60));
}

/// 5. 符号控制演示
/// 展示正负号的各种显示控制方法
fn demonstrate_sign_control() {
    println!("5. 符号控制");
    println!("   掌握正负号的显示控制技巧\n");
    
    let sign_values = [
        42.5,      // 正数
        -17.25,    // 负数
        0.0,       // 正零
        -0.0,      // 负零
        std::f64::INFINITY,     // 正无穷
        -std::f64::INFINITY,    // 负无穷
    ];
    
    println!("5.1 默认符号显示");
    println!("  默认情况下，只显示负号，正号省略:");
    for &value in &sign_values {
        println!("  {} -> 默认: '{}'", value, value);
    }
    
    println!("\n5.2 强制显示正号 ({{:+}})");
    println!("  使用 '+' 标志强制显示所有符号:");
    for &value in &sign_values {
        println!("  {} -> 带符号: '{:+}'", value, value);
    }
    
    println!("\n5.3 正数前加空格 ({{: }})");
    println!("  使用空格标志为正数预留符号位:");
    for &value in &sign_values {
        println!("  {} -> 空格填充: '{ }'", value, value);
    }
    
    println!("\n5.4 符号控制与对齐结合");
    let value_pairs = [(42.5, -42.5), (123.0, -123.0), (0.001, -0.001)];
    println!("  符号控制在对齐中的作用:");
    
    for (pos, neg) in value_pairs {
        println!("  正负数对比:");
        println!("    默认:     '{:>8}' vs '{:>8}'", pos, neg);
        println!("    强制符号: '{:+>8}' vs '{:+>8}'", pos, neg);
        println!("    空格符号: '{ :>8}' vs '{ :>8}'", pos, neg);
        println!();
    }
    
    println!("\n5.5 零填充与符号的交互");
    let zero_fill_values = [42.0, -42.0, 123.456, -123.456];
    println!("  零填充时符号的位置:");
    for &value in &zero_fill_values {
        println!("  {:>10} -> 零填充: {:010} -> 带符号零填充: {:+010}", 
                value, value, value);
    }
    
    println!("\n5.6 符号控制在不同格式中的表现");
    let format_value = 42.123;
    let neg_format_value = -42.123;
    
    println!("  正数 {} 的各种符号格式:", format_value);
    println!("    常规:     '{}'", format_value);
    println!("    带符号:   '{:+}'", format_value);
    println!("    空格:     '{ }'", format_value);
    println!("    科学计数: '{:+e}'", format_value);
    println!("    精度控制: '{:+.2}'", format_value);
    
    println!("\n  负数 {} 的各种符号格式:", neg_format_value);
    println!("    常规:     '{}'", neg_format_value);
    println!("    带符号:   '{:+}'", neg_format_value);
    println!("    空格:     '{ }'", neg_format_value);
    println!("    科学计数: '{:+e}'", neg_format_value);
    println!("    精度控制: '{:+.2}'", neg_format_value);
    
    println!("\n5.7 特殊情况：正零与负零");
    let pos_zero = 0.0;
    let neg_zero = -0.0;
    println!("  正零和负零的符号显示:");
    println!("    +0.0: '{}' vs '{:+}' vs '{ }'", pos_zero, pos_zero, pos_zero);
    println!("    -0.0: '{}' vs '{:+}' vs '{ }'", neg_zero, neg_zero, neg_zero);
    println!("  注意: 在某些上下文中，-0.0可能显示为0");
    
    println!("\n💡 符号控制要点:");
    println!("   - 默认只显示负号，正数无符号");
    println!("   - '+' 标志强制显示所有符号（+/-）");
    println!("   - ' ' (空格)标志为正数预留符号位，负数显示负号");
    println!("   - 零填充时，符号出现在填充零之前");
    println!("   - 符号控制与科学计数法、精度控制可以组合使用");
    
    println!("\n{}\n", "=".repeat(60));
}

/// 6. 舍入行为详解
/// 深入探讨浮点数在格式化时的舍入策略
fn demonstrate_rounding_behavior() {
    println!("6. 舍入行为详解");
    println!("   理解格式化时的舍入规则和边界情况\n");
    
    println!("6.1 基本舍入规则演示");
    println!("  Rust使用IEEE 754标准的\"四舍六入五成双\"规则:");
    
    let rounding_cases = [
        2.4,     // < 0.5，舍去
        2.5,     // = 0.5，舍入到偶数 (2)
        2.6,     // > 0.5，进位
        3.5,     // = 0.5，舍入到偶数 (4) 
        4.5,     // = 0.5，舍入到偶数 (4)
        5.5,     // = 0.5，舍入到偶数 (6)
        2.51,    // 略大于0.5，进位
        2.49,    // 略小于0.5，舍去
    ];
    
    println!("    原值   | 0位小数 | 说明");
    println!("  ---------|---------|----------------------------------");
    for &value in &rounding_cases {
        let rounded = format!("{:.0}", value);
        let explanation = match value {
            x if (x * 10.0) % 10.0 < 5.0 => "< 0.5，向下舍入",
            x if (x * 10.0) % 10.0 > 5.0 => "> 0.5，向上舍入",
        x if (x as f64).floor() as i32 % 2 == 0 => "= 0.5，舍入到偶数",
            _ => "= 0.5，舍入到偶数",
        };
        println!("  {:8.2} | {:>7} | {}", value, rounded, explanation);
    }
    
    println!("\n6.2 不同精度下的舍入行为");
    let precision_value = 12.3456789;
    println!("  原值: {}", precision_value);
    for precision in 0..=6 {
        println!("    {}位小数: {:.precision$}", precision, precision_value, precision = precision);
    }
    
    println!("\n6.3 边界情况的舍入");
    let boundary_cases = [
        0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5,
    ];
    println!("  .5的舍入规律（银行家舍入法）:");
    println!("    原值 | 整数部分 | 结果 | 解释");
    println!("  -------|----------|------|---------------------------");
    for &value in &boundary_cases {
        let integer_part = (value as f64).floor() as i32;
        let rounded = format!("{:.0}", value);
        let is_even = integer_part % 2 == 0;
        let explanation = if is_even { "偶数，保持" } else { "奇数，进位到偶数" };
        println!("  {:5.1} |    {:5} | {:>4} | {}", value, integer_part, rounded, explanation);
    }
    
    println!("\n6.4 负数的舍入行为");
    let negative_cases = [-2.4, -2.5, -2.6, -3.5, -4.5];
    println!("  负数遵循相同的舍入规则:");
    for &value in &negative_cases {
        println!("  {:5.1} -> {:.0}", value, value);
    }
    
    println!("\n6.5 科学计数法中的舍入");
    let sci_value = 1.23456789e-4;
    println!("  科学计数法: {}", sci_value);
    for precision in 1..=6 {
        println!("    {}位有效数字: {:.*e}", precision, precision - 1, sci_value);
    }
    
    println!("\n6.6 舍入误差的累积");
    println!("  连续舍入可能导致误差累积:");
    let original = 1.0 / 3.0; // 0.333...
    println!("  原值: {} (1/3)", original);
    
    let step1 = format!("{:.3}", original).parse::<f64>().unwrap();
    println!("  第一次舍入到3位: {}", step1);
    
    let step2 = format!("{:.2}", step1).parse::<f64>().unwrap();
    println!("  第二次舍入到2位: {}", step2);
    
    let direct = format!("{:.2}", original).parse::<f64>().unwrap();
    println!("  直接舍入到2位: {}", direct);
    
    println!("  累积误差: {:.10}", (step2 - direct).abs());
    
    println!("\n6.7 手动舍入控制");
    println!("  如果需要特定的舍入行为，可以手动实现:");
    let test_values = [2.4, 2.5, 2.6, 3.5];
    
    for &value in &test_values {
        println!("  {} -> 四舍五入: {}, 向上取整: {}, 向下取整: {}, 向零取整: {}", 
                value,
                manual_round(value),      // 传统四舍五入
                value.ceil(),             // 向上取整
                value.floor(),            // 向下取整
                value.trunc());           // 向零取整
    }
    
    println!("\n💡 舍入行为要点:");
    println!("   - Rust默认使用银行家舍入法（四舍六入五成双）");
    println!("   - 这种方法减少了舍入偏差，但可能与直觉不符");
    println!("   - .5时舍入到最近的偶数");
    println!("   - 负数遵循相同的舍入规则");
    println!("   - 连续舍入可能累积误差");
    println!("   - 需要特定舍入行为时，应手动实现");
    
    println!("\n{}\n", "=".repeat(60));
}

/// 7. 特殊值格式化演示
/// 展示NaN、无穷大等特殊值的格式化处理
fn demonstrate_special_values_formatting() {
    println!("7. 特殊值格式化");
    println!("   掌握NaN、无穷大等特殊值的格式化处理\n");
    
    let special_values = [
        ("正无穷", f64::INFINITY),
        ("负无穷", f64::NEG_INFINITY),
        ("NaN", f64::NAN),
        ("正零", 0.0),
        ("负零", -0.0),
    ];
    
    println!("7.1 特殊值的基本格式化");
    for (name, value) in &special_values {
        println!("  {:<6}: {}", name, value);
    }
    
    println!("\n7.2 特殊值在不同格式下的表现");
    
    for (name, value) in &special_values {
        println!("  {}:", name);
        println!("    Display:  '{}'", value);
        println!("    Debug:    '{:?}'", value);
        println!("    科学计数: '{:e}'", value);
        println!("    精度控制: '{:.2}'", value);
        println!("    符号控制: '{:+}'", value);
        println!("    对齐:     '{:>10}'", value);
        println!();
    }
    
    println!("7.3 特殊值的识别和处理");
    println!("  检测特殊值的方法:");
    for (name, value) in &special_values {
        println!("  {} ({}):", name, value);
        println!("    is_finite():    {}", value.is_finite());
        println!("    is_infinite():  {}", value.is_infinite());
        println!("    is_nan():       {}", value.is_nan());
        println!("    is_normal():    {}", value.is_normal());
        println!("    is_subnormal(): {}", value.is_subnormal());
        println!("    is_sign_positive(): {}", value.is_sign_positive());
        println!("    is_sign_negative(): {}", value.is_sign_negative());
        println!();
    }
    
    println!("7.4 特殊值格式化的实际应用");
    let results = [
        ("计算结果", 42.5),
        ("除零错误", f64::INFINITY),
        ("无效操作", f64::NAN),
        ("负除零", f64::NEG_INFINITY),
    ];
    
    println!("  安全格式化输出:");
    for (desc, value) in results {
        let formatted = safe_format_float(value, 2);
        println!("  {}: {} -> {}", desc, value, formatted);
    }
    
    println!("\n💡 特殊值格式化要点:");
    println!("   - NaN会显示为'NaN'，不受精度控制影响");
    println!("   - 无穷大显示为'inf'或'-inf'");
    println!("   - 特殊值在对齐时按字符串长度计算");
    println!("   - 检查特殊值时使用专门的方法，不要直接比较");
    println!("   - 在实际应用中应对特殊值进行安全处理");
    
    println!("\n{}\n", "=".repeat(60));
}

/// 8. 数字分组和千位分隔符演示
/// 展示大数字的可读性格式化
fn demonstrate_number_grouping() {
    println!("8. 数字分组和千位分隔符");
    println!("   提高大数字的可读性\n");
    
    let large_numbers = [
        1234.5,
        12345.67,
        123456.789,
        1234567.8901,
        12345678.90123,
        123456789.012345,
        1234567890.123456789,
    ];
    
    println!("8.1 标准格式 vs 分组格式对比");
    println!("  {:>18} | {:>18}", "原始格式", "千位分隔符");
    println!("  {:-<18}-+-{:-<18}", "", "");
    
    for &number in &large_numbers {
        let standard = format!("{}", number);
        let grouped = add_thousand_separator(number);
        println!("  {:>18} | {:>18}", standard, grouped);
    }
    
    println!("\n8.2 不同精度下的千位分隔符");
    let test_number = 1234567.89123456;
    for precision in 0..=4 {
        let formatted = format!("{:.precision$}", test_number, precision = precision);
        let grouped = add_thousand_separator_with_precision(test_number, precision);
        println!("  {}位精度: {} -> {}", precision, formatted, grouped);
    }
    
    println!("\n8.3 负数的千位分隔符处理");
    let negative_numbers = [-1234.5, -123456.78, -1234567890.12];
    for &number in &negative_numbers {
        println!("  {} -> {}", number, add_thousand_separator(number));
    }
    
    println!("\n8.4 科学计数法不需要千位分隔符");
    for &number in &large_numbers {
        println!("  {:15} -> {:15e}", number, number);
    }
    
    println!("\n8.5 表格中的数字对齐");
    let financial_data = [
        ("营业收入", 12345678.90),
        ("营业成本", 8765432.10),
        ("毛利润", 3580246.80),
        ("净利润", 1234567.89),
    ];
    
    println!("  财务报表示例:");
    println!("  {:<12} | {:>20}", "项目", "金额");
    println!("  {:-<12}-+-{:->20}", "", "");
    for (item, amount) in financial_data {
        println!("  {:<12} | {:>20}", item, add_thousand_separator_with_precision(amount, 2));
    }
    
    println!("\n💡 数字分组要点:");
    println!("   - Rust标准库不提供内置的千位分隔符功能");
    println!("   - 可以使用第三方crate如num-format");
    println!("   - 手动实现时注意处理小数点和负数");
    println!("   - 不同地区可能使用不同的分隔符（逗号、空格、点）");
    
    println!("\n{}\n", "=".repeat(60));
}

/// 9. 货币和百分比格式化演示
/// 展示实际应用中的格式化需求
fn demonstrate_currency_percentage() {
    println!("9. 货币和百分比格式化");
    println!("   实际应用中的常见格式化需求\n");
    
    println!("9.1 货币格式化");
    let prices = [
        12.50,
        99.99,
        1234.56,
        0.99,
        10000.00,
        -25.75,  // 退款
    ];
    
    println!("  人民币格式化:");
    for &price in &prices {
        println!("    {} -> {}", price, format_as_rmb(price));
    }
    
    println!("\n  美元格式化:");
    for &price in &prices {
        println!("    {} -> {}", price, format_as_usd(price));
    }
    
    println!("\n9.2 百分比格式化");
    let percentages = [
        0.05,      // 5%
        0.1234,    // 12.34%
        0.9999,    // 99.99%
        1.0,       // 100%
        1.25,      // 125%
        -0.05,     // -5%
        0.00001,   // 0.001%
    ];
    
    println!("  百分比显示（2位小数）:");
    for &pct in &percentages {
        println!("    {} -> {}", pct, format_as_percentage(pct, 2));
    }
    
    println!("\n  百分比显示（1位小数）:");
    for &pct in &percentages {
        println!("    {} -> {}", pct, format_as_percentage(pct, 1));
    }
    
    println!("\n9.3 混合格式表格");
    let financial_report = [
        ("营业收入", 1000000.0, 1.0),
        ("营业成本", 600000.0, 0.6),
        ("毛利润", 400000.0, 0.4),
        ("销售费用", 150000.0, 0.15),
        ("管理费用", 100000.0, 0.1),
        ("净利润", 150000.0, 0.15),
    ];
    
    println!("  综合财务报表:");
    println!("  {:<12} | {:>15} | {:>10}", "项目", "金额", "占比");
    println!("  {:-<12}-+-{:->15}-+-{:->10}", "", "", "");
    for (item, amount, ratio) in financial_report {
        println!("  {:<12} | {:>15} | {:>10}", 
                item, 
                format_as_rmb(amount),
                format_as_percentage(ratio, 1));
    }
    
    println!("\n9.4 精确货币计算显示");
    println!("  避免浮点精度问题的货币显示:");
    let precise_amounts = [
        0.1 + 0.2,  // 经典的浮点精度问题
        1.0 / 3.0,  // 无限小数
        99.999,     // 接近整数
    ];
    
    for &amount in &precise_amounts {
        println!("    原值: {:.10} -> 货币: {}", amount, format_as_rmb(amount));
    }
    
    println!("\n9.5 本地化格式化");
    let amount = 1234567.89;
    println!("  不同地区的格式化风格:");
    println!("    中国:   {}", format_currency(amount, "￥", ",", ".", 2));
    println!("    美国:   {}", format_currency(amount, "$", ",", ".", 2));
    println!("    德国:   {}", format_currency(amount, "€", ".", ",", 2));
    println!("    印度:   {}", format_currency_indian(amount));
    
    println!("\n💡 货币和百分比格式化要点:");
    println!("   - 货币显示通常需要固定精度（如2位小数）");
    println!("   - 百分比需要乘以100并添加%符号");
    println!("   - 注意处理负值（退款、亏损等）");
    println!("   - 不同地区有不同的千位分隔符和小数点符号");
    println!("   - 大额货币可能需要科学计数法或特殊单位（万、亿）");
    
    println!("\n{}\n", "=".repeat(60));
}

/// 10. 自定义格式化实现演示
/// 展示如何实现自定义的格式化类型
fn demonstrate_custom_formatting() {
    println!("10. 自定义格式化实现");
    println!("    创建专门的格式化类型和方法\n");
    
    println!("10.1 包装类型的自定义格式化");
    let currency_values = [
        Currency::new(1234.56),
        Currency::new(-99.99),
        Currency::new(0.01),
        Currency::new(1000000.0),
    ];
    
    println!("  Currency类型的多种格式化:");
    for currency in &currency_values {
        println!("    值: {:.10}", currency.amount);
        println!("      Display:    {}", currency);
        println!("      Debug:      {:?}", currency);
        println!("      精度控制:   {:.0}", currency);
        println!("      科学计数:   {:e}", currency);
        println!();
    }
    
    println!("10.2 百分比类型的自定义格式化");
    let percentage_values = [
        Percentage::new(0.1234),
        Percentage::new(0.05),
        Percentage::new(1.5),
        Percentage::new(-0.25),
    ];
    
    for pct in &percentage_values {
        println!("    值: {}", pct.value);
        println!("      Display:   {}", pct);
        println!("      Debug:     {:?}", pct);
        println!("      精度控制:  {:.1}", pct);
        println!();
    }
    
    println!("10.3 科学记数法包装类型");
    let scientific_values = [
        Scientific::new(6.02214076e23),
        Scientific::new(1.602176634e-19),
        Scientific::new(299792458.0),
    ];
    
    for sci in &scientific_values {
        println!("    值: {}", sci.value);
        println!("      Display:    {}", sci);
        println!("      工程记数:   {:#}", sci);  // 使用alternate格式
        println!("      精度控制:   {:.2}", sci);
        println!();
    }
    
    println!("10.4 复合格式化类型");
    let measurements = [
        Measurement::new(25.6, "°C"),
        Measurement::new(9.8, "m/s²"),
        Measurement::new(3.14159, "rad"),
        Measurement::new(1234.5, "Hz"),
    ];
    
    for measurement in &measurements {
        println!("    Display: {}", measurement);
        println!("    Debug:   {:?}", measurement);
        println!("    对齐:    '{:>15}'", measurement);
        println!("    精度:    '{:.1}'", measurement);
        println!();
    }
    
    println!("10.5 条件格式化");
    let scores = [95.5, 67.8, 45.2, 89.0, 23.1];
    
    println!("  成绩等级显示:");
    for &score in &scores {
        let grade = Grade::from_score(score);
        println!("    {:.1}分 -> {}", score, grade);
        println!("      详细: {:?}", grade);
        println!("      简化: {:#}", grade);  // alternate格式显示简化版本
        println!();
    }
    
    println!("💡 自定义格式化要点:");
    println!("   - 实现std::fmt::Display trait用于用户友好显示");
    println!("   - 实现std::fmt::Debug trait用于调试输出");
    println!("   - 可以实现多个格式化trait以支持不同格式");
    println!("   - 使用fmt::Formatter的精度、宽度、对齐等参数");
    println!("   - alternate格式(#)可用于提供备选显示方式");
    
    println!("\n{}\n", "=".repeat(60));
}

// ============================================================================
// 辅助函数实现
// ============================================================================

/// 工程记数法格式化（指数为3的倍数）
fn format_engineering_notation(value: f64, precision: usize) -> String {
    if value == 0.0 {
        return format!("{:.precision$}e+00", value, precision = precision);
    }
    
    let log_val = value.abs().log10();
    let exp = (log_val / 3.0).floor() as i32 * 3;
    let mantissa = value / 10.0_f64.powi(exp);
    
    format!("{:.precision$}e{:+03}", mantissa, exp, precision = precision)
}

/// 手动四舍五入（传统方式）
fn manual_round(value: f64) -> f64 {
    if value >= 0.0 {
        (value + 0.5).floor()
    } else {
        (value - 0.5).ceil()
    }
}

/// 安全的浮点数格式化
fn safe_format_float(value: f64, precision: usize) -> String {
    if value.is_nan() {
        "NaN".to_string()
    } else if value.is_infinite() {
        if value.is_sign_positive() {
            "∞".to_string()
        } else {
            "-∞".to_string()
        }
    } else {
        format!("{:.precision$}", value, precision = precision)
    }
}

/// 添加千位分隔符
fn add_thousand_separator(value: f64) -> String {
    let formatted = format!("{}", value);
    add_commas_to_string(&formatted)
}

/// 添加千位分隔符（指定精度）
fn add_thousand_separator_with_precision(value: f64, precision: usize) -> String {
    let formatted = format!("{:.precision$}", value, precision = precision);
    add_commas_to_string(&formatted)
}

/// 为字符串添加逗号分隔符
fn add_commas_to_string(s: &str) -> String {
    let parts: Vec<&str> = s.split('.').collect();
    let integer_part = parts[0];
    let decimal_part = if parts.len() > 1 { parts[1] } else { "" };
    
    let mut result = String::new();
    let chars: Vec<char> = integer_part.chars().collect();
    let start_idx = if chars[0] == '-' { 1 } else { 0 };
    
    if start_idx > 0 {
        result.push('-');
    }
    
    for (i, &ch) in chars[start_idx..].iter().enumerate() {
        if i > 0 && (chars.len() - start_idx - i) % 3 == 0 {
            result.push(',');
        }
        result.push(ch);
    }
    
    if !decimal_part.is_empty() {
        result.push('.');
        result.push_str(decimal_part);
    }
    
    result
}

/// 人民币格式化
fn format_as_rmb(amount: f64) -> String {
    format!("￥{}", add_thousand_separator_with_precision(amount, 2))
}

/// 美元格式化
fn format_as_usd(amount: f64) -> String {
    format!("${}", add_thousand_separator_with_precision(amount, 2))
}

/// 百分比格式化
fn format_as_percentage(value: f64, precision: usize) -> String {
    format!("{:.precision$}%", value * 100.0, precision = precision)
}

/// 通用货币格式化
fn format_currency(amount: f64, symbol: &str, thousands_sep: &str, decimal_sep: &str, precision: usize) -> String {
    let formatted = format!("{:.precision$}", amount.abs(), precision = precision);
    let with_separators = formatted.replace(",", thousands_sep).replace(".", decimal_sep);
    let with_commas = add_commas_to_currency(&with_separators, thousands_sep);
    
    if amount < 0.0 {
        format!("-{}{}", symbol, with_commas)
    } else {
        format!("{}{}", symbol, with_commas)
    }
}

/// 印度卢比格式化（特殊的分组规则）
fn format_currency_indian(amount: f64) -> String {
    // 印度数字系统：第一个逗号在千位，之后每两位一个逗号
    let formatted = format!("{:.2}", amount.abs());
    let parts: Vec<&str> = formatted.split('.').collect();
    let integer_part = parts[0];
    let decimal_part = parts[1];
    
    let mut result = String::new();
    let chars: Vec<char> = integer_part.chars().collect();
    let len = chars.len();
    
    for (i, &ch) in chars.iter().enumerate() {
        if i > 0 {
            let remaining = len - i;
            if remaining == 3 || (remaining > 3 && (remaining - 3) % 2 == 0) {
                result.push(',');
            }
        }
        result.push(ch);
    }
    
    let final_amount = format!("{}.{}", result, decimal_part);
    if amount < 0.0 {
        format!("-₹{}", final_amount)
    } else {
        format!("₹{}", final_amount)
    }
}

fn add_commas_to_currency(s: &str, _sep: &str) -> String {
    // 简化实现，实际中可能需要更复杂的处理
    s.to_string()
}

// ============================================================================
// 自定义类型定义
// ============================================================================

/// 货币类型
#[derive(Debug, Clone, Copy)]
struct Currency {
    amount: f64,
}

impl Currency {
    fn new(amount: f64) -> Self {
        Currency { amount }
    }
}

impl fmt::Display for Currency {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let precision = f.precision().unwrap_or(2);
        if f.alternate() {
            write!(f, "${:.precision$}", self.amount, precision = precision)
        } else {
            write!(f, "￥{}", add_thousand_separator_with_precision(self.amount, precision))
        }
    }
}

impl fmt::LowerExp for Currency {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "￥{:e}", self.amount)
    }
}

/// 百分比类型
#[derive(Debug, Clone, Copy)]
struct Percentage {
    value: f64,
}

impl Percentage {
    fn new(value: f64) -> Self {
        Percentage { value }
    }
}

impl fmt::Display for Percentage {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let precision = f.precision().unwrap_or(2);
        write!(f, "{:.precision$}%", self.value * 100.0, precision = precision)
    }
}

/// 科学记数法包装类型
#[derive(Debug, Clone, Copy)]
struct Scientific {
    value: f64,
}

impl Scientific {
    fn new(value: f64) -> Self {
        Scientific { value }
    }
}

impl fmt::Display for Scientific {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let precision = f.precision().unwrap_or(6);
        if f.alternate() {
            // 工程记数法
            write!(f, "{}", format_engineering_notation(self.value, precision))
        } else {
            write!(f, "{:.precision$e}", self.value, precision = precision)
        }
    }
}

/// 测量值类型
#[derive(Debug, Clone)]
struct Measurement {
    value: f64,
    unit: String,
}

impl Measurement {
    fn new(value: f64, unit: &str) -> Self {
        Measurement {
            value,
            unit: unit.to_string(),
        }
    }
}

impl fmt::Display for Measurement {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let precision = f.precision().unwrap_or(2);
        if let Some(width) = f.width() {
            let formatted = format!("{:.precision$} {}", self.value, self.unit, precision = precision);
            write!(f, "{:width$}", formatted, width = width)
        } else {
            write!(f, "{:.precision$} {}", self.value, self.unit, precision = precision)
        }
    }
}

/// 成绩等级类型
#[derive(Debug, Clone)]
struct Grade {
    score: f64,
    letter: char,
    description: String,
}

impl Grade {
    fn from_score(score: f64) -> Self {
        let (letter, description) = match score {
            s if s >= 90.0 => ('A', "优秀"),
            s if s >= 80.0 => ('B', "良好"),
            s if s >= 70.0 => ('C', "中等"),
            s if s >= 60.0 => ('D', "及格"),
            _ => ('F', "不及格"),
        };
        
        Grade {
            score,
            letter,
            description: description.to_string(),
        }
    }
    
}

impl fmt::Display for Grade {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if f.alternate() {
            write!(f, "{}", self.letter)
        } else {
            write!(f, "{} ({}) - {:.1}分", self.letter, self.description, self.score)
        }
    }
}
